package com.aaa.power.service.impl;

import com.aaa.common.bo.TreeNode;
import com.aaa.common.constant.ReturnCode;
import com.aaa.common.util.Result;
import com.aaa.power.dao.MenuDao;
import com.aaa.power.entity.Menu;
import com.aaa.power.service.MenuService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import javax.servlet.http.HttpSession;
import java.util.ArrayList;
import java.util.List;

/**
 * 菜单权限表(Menu)表服务实现类
 *
 * @author makejava
 * @since 2020-11-09 16:31:26
 */
@Service("menuService")
public class MenuServiceImpl implements MenuService {
    @Resource
    private MenuDao menuDao;

    @Autowired
    private HttpSession session;
    /**
     * 通过ID查询单条数据
     *
     * @param menuId 主键
     * @return 实例对象
     */
    @Override
    public Menu queryById(Integer menuId) {
        return this.menuDao.queryById(menuId);
    }

    /**
     * 根据用户id查找所有功能菜单，并获得树形结构
     * @return
     */
    @Override
    public List<TreeNode> queryMenuByUserId(Integer userId) {
        //从session中获取用户id
//        Integer userId=null;
//        if(session!=null){
//            userId=session.getAttribute("userInfo").get("userId");
//        }
        //把Menu集合转换为List<TreeNode>
        List<Menu> menus=menuDao.queryMenuByUserId(userId);
        //实例化集合，用于接受数据
        List<TreeNode> treeNodes=new ArrayList<>();
        //循环前判断，防止空指针
        if (menus!=null&&menus.size()>0){
            TreeNode treeNode=null;
            //循环
            for (Menu menu:menus){
                treeNode=this.menuToTreeNod(menu);
                //查找一级节点
                if (menu.getParentId()==0){
                    treeNode=this.menuToTreeNod(menu);
                    //查找子节点
                    bindChildren(treeNode,menus);
                    treeNodes.add(treeNode);
                }
            }
        }
        return treeNodes;
    }

    @Override
    public List<TreeNode> queryAllToTreeData() {
        //把Menu集合转换为List<TreeNode>
        List<Menu> menus=menuDao.queryAll(null);
        //实例化集合，用于接受数据
        List<TreeNode> treeNodes=new ArrayList<>();
        //循环前判断，防止空指针
        if (menus!=null&&menus.size()>0){
            TreeNode treeNode=null;
            //循环
            for (Menu menu:menus){
                //查找一级节点
                if (menu.getParentId()==0){
                    treeNode=this.menuToTreeNod(menu);
                    //查找子节点
                    bindChildren(treeNode,menus);
                    treeNodes.add(treeNode);
                }
            }
        }
        return treeNodes;
    }

    /**
     * menu对象转换为treeNode对象
     * @param menu
     * @return
     */
    private TreeNode menuToTreeNod(Menu menu){
        TreeNode treeNode=new TreeNode();
        treeNode.setId(menu.getMenuId());
        treeNode.setParentId(menu.getParentId());
        treeNode.setLabel(menu.getMenuName());
        treeNode.setIcon(menu.getIcon());
        treeNode.setUrl(menu.getUrl());
        treeNode.setVisible(menu.getVisible());
        return treeNode;
    }

    /**
     * 递归查找子节点
     * @param currentNode
     * @param menus
     */
    private void bindChildren(TreeNode currentNode,List<Menu> menus){

        for (Menu menu:menus){
            //如果循环节点的父id等于当前节点的id，说明循环节点是当前节点的孩子
            if (currentNode.getId()==menu.getParentId()){
                //获取孩子集合（第一次获取时肯定时空对象）
                List<TreeNode> children=currentNode.getChildren();
                //为空实例化对象
                if (children==null){
                    children=new ArrayList<>();
                }
                TreeNode treeNode=this.menuToTreeNod(menu);
                //递归时，如果某节点是当前节点的子节点，设置它的节点名称为当前节点名称
                treeNode.setParentName(currentNode.getLabel());
                //添加孩子
                children.add(treeNode);
                //绑定
                currentNode.setChildren(children);
                //自己调用自己，查找孩子
                bindChildren(treeNode,menus);
            }
        }
    }

    /**
     * 查询多条数据
     *
     * @param offset 查询起始位置
     * @param limit  查询条数
     * @return 对象列表
     */
    @Override
    public List<Menu> queryAllByLimit(int offset, int limit) {
        return this.menuDao.queryAllByLimit(offset, limit);
    }

    /**
     * 新增数据
     *
     * @param menu 实例对象
     * @return 实例对象
     */
    @Override
    public Menu insert(Menu menu) {
        this.menuDao.insert(menu);
        return menu;
    }

    /**
     * 修改数据
     *
     * @param menu 实例对象
     * @return 实例对象
     */
    @Override
    public Menu update(Menu menu) {
        this.menuDao.update(menu);
        return this.queryById(menu.getMenuId());
    }

    /**
     * 通过主键删除数据
     *
     * @param menuId 主键
     * @return 是否成功
     */
    @Override
    public boolean deleteById(Integer menuId) {
        return this.menuDao.deleteById(menuId) > 0;
    }

    @Override
    public Result queryUrlNotNull() {
        Menu menu = new Menu();
        //1 表示url不空，0 表示url为空
        menu.setIsNullUrl(1);
        //0为非隐藏菜单，1 表示隐藏菜单
        menu.setVisible(0);
        return new Result(ReturnCode.SUCCESSS.getCode(),
                ReturnCode.SUCCESSS.getMsg(),menuDao.queryAll(menu));
    }
}